// // 这题纯dfs会超时，要用到状态压缩dp的辅助
// #include <iostream>
// #include <vector>
// #include <cmath>
// #include <algorithm>
// #include <limits.h>

// using namespace std;

// typedef pair<double, double> PII;
// int n;
// vector<PII> a;
// vector<vector<double>> dist; // 距离矩阵
// vector<vector<double>> dp;   // DP表，dp[mask][i]表示访问了mask中所有点后，最后一个访问的点是i时的最短路径

// double calc_distance(int i, int j) {
//     return sqrt((a[i].first - a[j].first) * (a[i].first - a[j].first) +
//                 (a[i].second - a[j].second) * (a[i].second - a[j].second));
// }

// void tsp() {
//     // 初始化距离矩阵
//     dist.resize(n, vector<double>(n));
//     for (int i = 0; i < n; i++) {
//         for (int j = 0; j < n; j++) {
//             dist[i][j] = calc_distance(i, j);
//         }
//     }

//     // DP 初始化
//     dp.resize(1 << n, vector<double>(n, INT_MAX));
//     dp[1][0] = 0;  // 从点0开始，已经访问过点0，路径为0

//     // 状态转移
//     for (int mask = 1; mask < (1 << n); mask++) {
//         for (int u = 0; u < n; u++) {
//             if (mask & (1 << u)) {  // 如果u在mask中
//                 for (int v = 0; v < n; v++) {
//                     if (!(mask & (1 << v))) {  // 如果v没有被访问过
//                         int new_mask = mask | (1 << v);
//                         dp[new_mask][v] = min(dp[new_mask][v], dp[mask][u] + dist[u][v]);
//                     }
//                 }
//             }
//         }
//     }

//     // 计算最短路径：从任意一个点返回到0点
//     double result = INT_MAX;
//     for (int i = 1; i < n; i++) {
//         result = min(result, dp[(1 << n) - 1][i] + dist[i][0]);
//     }

//     printf("%.2lf\n", result);
// }

// int main() {
//     cin >> n;
//     a.resize(n);
//     for (int i = 0; i < n; i++) {
//         cin >> a[i].first >> a[i].second;
//     }

//     tsp();
//     return 0;
// }

    #include<stdio.h>
    #include<math.h>
    int n;
    double a[20],b[20],dp[65000][20];
    bool v[20];
    double ans=1e9;
    double dis(int x,int y){
    	return sqrt((a[x]-a[y])*(a[x]-a[y])+(b[x]-b[y])*(b[x]-b[y]));//距离公式
    }
    void dfs(int t,int now,double s,int b){
    	if(s>ans) return; //剪枝
    	if(t==n){
    		ans=ans<s?ans:s;
    		return;
    	}
    	for(register int i=1;i<=n;i++){
    		if(!v[i]){
    			int p=b+(1<<(i-1));//状压存状态
    			if(dp[p][i]!=0&&dp[p][i]<=s+dis(now,i)) continue;//判断条件+优化
    			v[i]=1;
    			dp[p][i]=s+dis(now,i);
    			dfs(t+1,i,dp[p][i],p);
    			v[i]=0;//回溯
    		}
    	}
    }
    int main(){
    	scanf("%d",&n);
    	for(register int i=1;i<=n;i++)
    		scanf("%lf%lf",&a[i],&b[i]);
    	dfs(0,0,0,0);
    	printf("%.2lf\n",ans);
    	return 0;
        
    }


    // #include <cstdio>
    // #include <cstring> 
    // #include <cmath> 
    // #define min(a,b) (((a)<(b))?(a):(b)) 
    // //洛谷 P1433 吃奶酪 状压DP
    // double a[20][20];//预处理，从第i块到第j块的距离，使用两点之间距离公式 
    // double x[20],y[20];//每块奶酪的横、纵坐标
    // double F[18][34000];//状压DP数组 在第i个点上，走过的二进制状态的十进制表达为j时，最短的距离 
    // int N; 
    // double distance(int v,int w)//计算第v个和第w个奶酪之间的距离 
    // {
    // 	return sqrt((x[v]-x[w])*(x[v]-x[w])+(y[v]-y[w])*(y[v]-y[w]));//两点间距离公式 
    // }
    // int main()
    // {
    // 	int i,j,k;
    // 	double ans;
    // 	memset(F,127,sizeof(F));//这样可以给浮点数赋值无穷大 
    // 	ans=F[0][0];
    // 	scanf("%d",&N);
    // 	for(i=1;i<=N;i++)
    // 	{
    // 		scanf("%lf%lf",&x[i],&y[i]);//数据读入 
    // 	}
    // 	x[0]=0;y[0]=0;
    // 	for(i=0;i<=N;i++)
    // 	{
    // 		for(j=i+1;j<=N;j++)
    // 		{
    // 			a[i][j]=distance(i,j);//初始化距离数组 
    // 			a[j][i]=a[i][j];
    // 		}
    // 	} 
    // 	for(i=1;i<=N;i++)//初始化 
    // 	{
    // 		F[i][(1<<(i-1))]=a[0][i];//在i点上且只有经过i点时距离是原点到i点的距离 
    // 	}
    // 	for(k=1;k<(1<<N);k++)//枚举所有二进制的状态 
    // 	{
    // 		for(i=1;i<=N;i++)
    // 		{
    // 			if((k&(1<<(i-1)))==0)
    // 				continue;//i的位置没被走过，所以不需要再继续计算了 
    // 			for(j=1;j<=N;j++)
    // 			{
    // 				if(i==j)
    // 					continue;//同一个点不需要再计算 
    // 				if((k&(1<<(j-1)))==0)
    // 					continue;//j的位置没走过  
    // 				F[i][k]=min(F[i][k],F[j][k-(1<<(i-1))]+a[i][j]);
    // 			} 
    // 		} 
    // 	} 
    // 	for(i=1;i<=N;i++)
    // 	{
    // 		ans=min(ans,F[i][(1<<N)-1]);
    // 	}
    // 	printf("%.2f\n",ans);
    // }
